﻿using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Threading;

namespace fap
{
    /// <summary>
    /// Page1.xaml 的交互逻辑
    /// </summary>
    public partial class 主页主显示 : UserControl
    {
        public 主页主显示()
        {
            InitializeComponent();
            连接状态.DataContext = 运动控制数据.西门子PLC;
            手动状态.DataContext = 运动控制数据.M读取结果[3];
            产量计数显示.DataContext = 运动控制数据.参数读取结果[1];
            生产节拍计数.DataContext = 运动控制数据.参数读取结果[0];
        }



        public DispatcherTimer timer;
        public Thread 刷新界面线程;


        #region   申明数据
        #endregion

        #region 按钮显示
        int 开始标识 = 0;
        public void 开始按键显示()
        {

            Uri ur = null;
            if (运动控制数据.M读取结果[(int)枚举.M枚举.运行].结果)
            {
                if (开始标识 == 1)
                {
                    return;
                }
                ur = new Uri("/fap;component/素材/主显示页面/开始.png", UriKind.Relative);
                开始标识 = 1;
            }
            else
            {
                if (开始标识 == 0)
                {
                    return;
                }
                ur = new Uri("/fap;component/素材/主显示页面/开始灰色.png", UriKind.Relative);
                开始标识 = 0;

            }

            Dispatcher.Invoke((Action)(() =>
            {
                BitmapImage bp = new BitmapImage(ur);

                开始按钮.Source = bp;


            }));



        }
        int 停止标识 = 0;

        public void 停止按键显示()
        {
            Uri ur = null;
            if (运动控制数据.M读取结果[(int)枚举.M枚举.停止].结果)

            {
                if (停止标识 == 1)
                {
                    return;
                }
                ur = new Uri("/fap;component/素材/主显示页面/停止.png", UriKind.Relative);
                停止标识 = 1;
            }
            else
            {
                if (停止标识 == 0)
                {
                    return;
                }
                ur = new Uri("/fap;component/素材/主显示页面/停止灰色.png", UriKind.Relative);
                停止标识 = 0;

            }
            Dispatcher.Invoke((Action)(() =>
            {
                BitmapImage bp = new BitmapImage(ur);

                停止按钮.Source = bp;


            }));



        }
        int 暂停标识 = 0;
        public void 暂停按键显示()
        {
            Uri ur = null;
            if (运动控制数据.M读取结果[(int)枚举.M枚举.暂停].结果)

            {
                if (暂停标识 == 1)
                {
                    return;
                }
                ur = new Uri("/fap;component/素材/主显示页面/暂停.png", UriKind.Relative);
                暂停标识 = 1;

            }
            else
            {
                if (暂停标识 == 0)
                {
                    return;
                }
                ur = new Uri("/fap;component/素材/主显示页面/暂停灰色.png", UriKind.Relative);
                暂停标识 = 0;

            }
            Dispatcher.Invoke((Action)(() =>
            {
                BitmapImage bp = new BitmapImage(ur);

                暂停按钮.Source = bp;


            }));

        }
        int 复位标识 = 0;

        public void 复位按键显示()
        {
            Uri ur = null;
            if (运动控制数据.M读取结果[(int)枚举.M枚举.复位].结果)

            {
                if (复位标识 == 1)
                {
                    return;
                }
                ur = new Uri("/fap;component/素材/主显示页面/复位.png", UriKind.Relative);
                复位标识 = 1;
            }
            else
            {
                if (复位标识 == 0)
                {
                    return;
                }
                ur = new Uri("/fap;component/素材/主显示页面/复位灰色.png", UriKind.Relative);
                复位标识 = 0;
            }
            Dispatcher.Invoke((Action)(() =>
            {
                BitmapImage bp = new BitmapImage(ur);

                复位按钮.Source = bp;

            }));

        }

        int 手自动标识 = 0;


        public void 界面刷新线程方法()
        {
            string 报警信息 = "";
            string 曾经信息 = "";
            while (true)
            {
                try
                {
                    Thread.Sleep(100);
                    开始按键显示();
                    停止按键显示();
                    暂停按键显示();
                    复位按键显示();


                    switch (运动控制数据.状态结果)
                    {
                        case 1:
                            {
                                Dispatcher.Invoke((Action)(() =>
                                {
                                    设备状态显示.Content = "设 备 待 机 中";

                                }));
                                break;
                            }
                        case 2:
                            {
                                Dispatcher.Invoke((Action)(() =>
                                {
                                    设备状态显示.Content = "设 备 运 行 中";

                                }));
                                break;
                            }
                        case 3:
                            {
                                Dispatcher.Invoke((Action)(() =>
                                {
                                    设备状态显示.Content = "设 备 异 常";

                                }));
                                break;
                            }
                    }
                

                    for (int i = 0; i < 运动控制数据.报警读取结果.Count(); i++)
                    {
                        if (运动控制数据.报警读取结果[i].结果)
                        {
                        

                            string[] 信息 = Enum.GetNames(typeof(枚举.报警枚举));
                            报警信息 = 信息[i];
                            if (报警信息 == ""|| 报警信息 == 曾经信息)
                            {
                              break;
                            }
                            else
                            {
                                窗口.主页主显示.显示("报警" + 报警信息);
                                曾经信息= 信息[i];
                                break;
                            }

                        }
                        if(i== 运动控制数据.报警读取结果.Count())
                        {
                            报警信息 = "";
                            曾经信息 = "";
                        }
                    }
                }
                catch (Exception ex) 
                
                { 
                MessageBox.Show(ex.ToString());
                
                
                }
              
            }
        }
        private void 鼠标进入(object sender, MouseEventArgs e)
        {
            Image ig = sender as Image;
            //switch (ig.Tag.ToString())
            //{
            //    case "开始":
            //        {
            //            开始按键显示();


            //            break;
            //        }
            //    case "暂停":
            //        {
            //            暂停按键显示();

            //            break;
            //        }
            //    case "停止":
            //        {
            //            停止按键显示();

            //            break;
            //        }
            //    case "复位":
            //        {
            //            复位按键显示();
            //            break;
            //        }
            //    case "显示一":
            //        {
            //            Uri ur = new Uri("/fap;component/素材/主显示页面/主显示框2.png", UriKind.Relative);
            //            BitmapImage bp = new BitmapImage(ur);
            //            ig.Source = bp;
            //            break;

            //        }
            //    case "显示二":
            //        {
            //            Uri ur = new Uri("/fap;component/素材/主显示页面/操作窗口显示.png", UriKind.Relative);
            //            BitmapImage bp = new BitmapImage(ur);
            //            ig.Source = bp;
            //            break;
            //        }



            //}
            TimeSpan timeSpan = new TimeSpan(0, 0, 0, 0, 300);
            WPF相应类.ScaleEasingAnimationShow(ig, 1, 1.07, 2, timeSpan);
        }
        private void 鼠标离开(object sender, MouseEventArgs e)
        {
            Image ig = sender as Image;
            //switch (ig.Tag.ToString())
            //{
            //    case "开始":
            //        {
            //            开始按键显示();


            //            break;
            //        }
            //    case "暂停":
            //        {
            //            暂停按键显示();

            //            break;
            //        }
            //    case "停止":
            //        {
            //            停止按键显示();

            //            break;
            //        }
            //    case "复位":
            //        {
            //            复位按键显示();

            //            break;
            //        }
            //    case "显示一":
            //        {
            //            Uri ur = new Uri("/fap;component/素材/主显示页面/主显示框2.png", UriKind.Relative);
            //            BitmapImage bp = new BitmapImage(ur);
            //            ig.Source = bp;
            //            break;
            //        }
            //    case "显示二":
            //        {
            //            Uri ur = new Uri("/fap;component/素材/主显示页面/操作窗口显示.png", UriKind.Relative);
            //            BitmapImage bp = new BitmapImage(ur);
            //            ig.Source = bp;
            //            break;
            //        }




            //}
            TimeSpan timeSpan = new TimeSpan(0, 0, 0, 0, 300);
            WPF相应类.ScaleEasingAnimationShow(ig, 1.07, 1, 2, timeSpan);
        }
        private void 鼠标进入2(object sender, MouseEventArgs e)
        {
            Grid ig = sender as Grid;
            //switch (ig.Tag.ToString())
            //{

            //    case "显示一":
            //        {
            //            Uri ur = new Uri("/fap;component/素材/主显示页面/主显示框2.png", UriKind.Relative);
            //            BitmapImage bp = new BitmapImage(ur);
            //            ig.Source = bp;
            //            break;

            //        }
            //    case "显示二":
            //        {
            //            Uri ur = new Uri("/fap;component/素材/主显示页面/操作窗口显示.png", UriKind.Relative);
            //            BitmapImage bp = new BitmapImage(ur);
            //            ig.Source = bp;
            //            break;
            //        }



            //}
            TimeSpan timeSpan = new TimeSpan(0, 0, 0, 0, 300);
            WPF相应类.ScaleEasingAnimationShow(ig, 1, 1.07, 2, timeSpan);
        }
        private void 鼠标离开2(object sender, MouseEventArgs e)
        {
            Grid ig = sender as Grid;

            TimeSpan timeSpan = new TimeSpan(0, 0, 0, 0, 300);
            WPF相应类.ScaleEasingAnimationShow(ig, 1.07, 1, 2, timeSpan);
        }

        #endregion
        private void Image_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            Image obj = (Image)sender;
            switch (obj.Tag)
            {
                case "开始":
                    {
                        //运动控制数据.修改M点位 = 枚举.M枚举.运行;
                        //运动控制数据.M写入 = true;
                        break;
                    }
                case "暂停":
                    {
                        //运动控制数据.修改M点位 = 枚举.M枚举.暂停;
                        //运动控制数据.M写入 = true;
                        break;
                    }
                case "停止":
                    {
                        //运动控制数据.修改M点位 = 枚举.M枚举.停止;
                        //运动控制数据.M写入 = true;

                        break;
                    }
                case "复位":
                    {

                        //运动控制数据.修改M点位 = 枚举.M枚举.复位;
                        //运动控制数据.M写入 = true;

                        break;
                    }


            }

        }

        private void Image_MouseLeftButtonDown2(object sender, MouseButtonEventArgs e)
        {
            Grid obj = (Grid)sender;
            switch (obj.Tag)
            {

                case "显示一":
                    {
                        窗口.主页.切换界面(4);

                        break;
                    }
                case "显示二":
                    {
                        窗口.主页.切换界面(3);

                        break;
                    }
                case "显示三":
                    {

                        窗口.主页.切换界面(1);


                        break;
                    }

                case "退出":
                    {

                        提示页面 form = new 提示页面("确定要退出程序吗？");
                        form.WindowStartupLocation = WindowStartupLocation.CenterScreen;
                        form.ShowDialog();
                        //   Application.Exit();  //强制所有消息中止，退出所有的窗体，但是若有托管线程（非主线程），也无法干净地退出；  

                        // Application.ExitThread(); //强制中止调用线程上的所有消息，同样面临其它线程无法正确退出的问题；  
                        if (form.是否)
                        {
                            form.Close();
                            System.Environment.Exit(0);   //这是最彻底的退出方式，不管什么线程都被强制退出，把程序结束的很干净，退出时有可能会抛出异常  
                        }
                        else
                        {
                            form.Close();
                        }


                        //  System.Diagnostics.Process tt = System.Diagnostics.Process.GetProcessById(System.Diagnostics.Process.GetCurrentProcess().Id);
                        // tt.Kill();//直接杀死与本程序相关的所有进程，有可能会导致数据丢失，但是不会抛出异常。

                        break;
                    }
            }

        }
        public void 窗口初始化()
        {
            //主数据.显示1 = 显示1.HalconWindow;
            刷新界面线程 = new Thread(界面刷新线程方法);
            刷新界面线程.Start();
            运动控制数据.连接PLC();
           
            推动一正.AddHandler(Button.MouseDownEvent, new RoutedEventHandler(bt_MouseDown), true);
            推动一正.AddHandler(Button.MouseUpEvent, new RoutedEventHandler(bt_MouseUp), true);
            推动二正.AddHandler(Button.MouseDownEvent, new RoutedEventHandler(bt_MouseDown), true);
            推动二正.AddHandler(Button.MouseUpEvent, new RoutedEventHandler(bt_MouseUp), true);
            推动三正.AddHandler(Button.MouseDownEvent, new RoutedEventHandler(bt_MouseDown), true);
            推动三正.AddHandler(Button.MouseUpEvent, new RoutedEventHandler(bt_MouseUp), true);
            推动四正.AddHandler(Button.MouseDownEvent, new RoutedEventHandler(bt_MouseDown), true);
            推动四正.AddHandler(Button.MouseUpEvent, new RoutedEventHandler(bt_MouseUp), true);
            推动一反.AddHandler(Button.MouseDownEvent, new RoutedEventHandler(bt_MouseDown), true);
            推动一反.AddHandler(Button.MouseUpEvent, new RoutedEventHandler(bt_MouseUp), true);
            推动二反.AddHandler(Button.MouseDownEvent, new RoutedEventHandler(bt_MouseDown), true);
            推动二反.AddHandler(Button.MouseUpEvent, new RoutedEventHandler(bt_MouseUp), true);
            推动三反.AddHandler(Button.MouseDownEvent, new RoutedEventHandler(bt_MouseDown), true);
            推动三反.AddHandler(Button.MouseUpEvent, new RoutedEventHandler(bt_MouseUp), true);
            推动四反.AddHandler(Button.MouseDownEvent, new RoutedEventHandler(bt_MouseDown), true);
            推动四反.AddHandler(Button.MouseUpEvent, new RoutedEventHandler(bt_MouseUp), true);
          

        }






        #region 主程序


        private void Label_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            //this.WindowState = WindowState.Minimized;
            System.Windows.Application.Current.MainWindow.WindowState = System.Windows.WindowState.Minimized;
        }


        public List<string> 获取料号()
        {
            List<string> 料号 = new List<string>();
            DirectoryInfo dir = new DirectoryInfo(运动控制数据.参数路径);
            string name;
            if (!Directory.Exists(运动控制数据.参数路径))
            {
                Directory.CreateDirectory(运动控制数据.参数路径);
            }
            foreach (DirectoryInfo directoryName in dir.GetDirectories())
            {
                name = directoryName.Name;
                料号.Add(name);
            }
            return 料号;
        }


        private void MenuItem_Click_label(object sender, RoutedEventArgs e)
        {
            MenuItem menuItem = (MenuItem)sender;
            if (menuItem.Header.ToString() == "复制配方")
            {
                if (运动控制数据.Product路径 != "")
                {
                    string str = 运动控制数据.Product路径;
                    输入页面 form = new 输入页面();
                    form.ShowDialog();
                    string strcopy = 运动控制数据.参数路径 + form.输入;
                    File_Directory.CopyFileAndDir(str, strcopy);
                }
            }
            if (menuItem.Header.ToString() == "新建配方")
            {

            }
            if (menuItem.Header.ToString() == "删除配方")
            {

            }
            if (menuItem.Header.ToString() == "修改配方名")
            {
                string str = 运动控制数据.Product路径;
                输入页面 form = new 输入页面();
                form.ShowDialog();
                string strcopy = 运动控制数据.参数路径 + form.输入;
                File_Directory.DelectFile(strcopy);
            }
         
        }


        public void 显示(string 信息)
        {
            Dispatcher.Invoke((Action)(() =>
            {
                WPF相应类.写入rich(信息窗口, 信息);

            }));


        }

        #endregion


        private void Button_Click(object sender, RoutedEventArgs e)
        {
            Button button = (Button)sender;
            switch (button.Name)
            {
                case "保存":
                    {
                        运动控制数据.保存();
                        break;
                    }
                case "新建配方":
                    {
                        输入页面 form = new 输入页面();
                        form.ShowDialog();
                        string strcopy = 运动控制数据.参数路径 + form.输入;
                        运动控制数据.Product路径 = strcopy;
                      

                        运动控制数据.保存();
                        break;
                    }
                case "删除配方":
                    {
                        string str = 运动控制数据.Product路径;
                     
                        File_Directory.DelectFile(str);
                        break;
                    }


            }
            配方选择.ItemsSource = 获取料号();

        }

        private void UserControl_Initialized(object sender, EventArgs e)
        {
            窗口初始化();
        }
        private void 生产节拍计数复制__C__Drop(object sender, EventArgs e)
        {


        }

        private void 配方选择_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            try
            {
                运动控制数据.Product路径 = 运动控制数据.参数路径 + 配方选择.SelectedValue.ToString();
                运动控制数据.Product名字 = 配方选择.SelectedValue.ToString();
                运动控制数据.读取();
                窗口.主页主显示.显示("切换配方：" + 运动控制数据.Product名字);
            }
            catch
            {
                配方选择.SelectedIndex = 0;
                运动控制数据.Product路径 = 运动控制数据.参数路径 + 配方选择.SelectedValue.ToString();
                运动控制数据.Product名字 = 配方选择.SelectedValue.ToString();
                运动控制数据.读取();
                窗口.主页主显示.显示("切换配方：" + 运动控制数据.Product名字);
            }
      


        }



        private void 手动状态_Click(object sender, RoutedEventArgs e)
        {
            if(运动控制数据.M读取结果[3].结果)
            {
                运动控制数据.修改M点位 = 枚举.M枚举.手自动;

                运动控制数据.M写入 = true;
                运动控制数据.M写入值 = false;
                窗口.主页主显示.显示("切换手动");


            }
            else
            {
                运动控制数据.修改M点位 = 枚举.M枚举.手自动;

                运动控制数据.M写入 = true;
                运动控制数据.M写入值 = true;
                窗口.主页主显示.显示("切换自动");
            }

        }



        private void bt_MouseDown(object sender, RoutedEventArgs e)
        {
            Button button = (Button)sender;
            switch (button.Name)
            {
                case "推动一正":
                    {
                        运动控制数据.修改SD点位 = 枚举.SD枚举.推动1正;
                        运动控制数据.SD写入 = true;

                        break;
                    }
                case "推动二正":
                    {
                        运动控制数据.修改SD点位 = 枚举.SD枚举.推动2正;
                        运动控制数据.SD写入 = true;
                        break;
                    }
                case "推动三正":
                    {
                        运动控制数据.修改SD点位 = 枚举.SD枚举.推动3正;
                        运动控制数据.SD写入 = true;
                        break;
                    }
                case "推动四正":
                    {
                        运动控制数据.修改SD点位 = 枚举.SD枚举.推动4正;
                        运动控制数据.SD写入 = true;
                        break;
                    }
                case "推动一反":
                    {
                        运动控制数据.修改SD点位 = 枚举.SD枚举.推动1反;
                        运动控制数据.SD写入 = true;
                        break;
                    }
                case "推动二反":
                    {
                        运动控制数据.修改SD点位 = 枚举.SD枚举.推动2反;
                        运动控制数据.SD写入 = true;
                        break;
                    }
                case "推动三反":
                    {
                        运动控制数据.修改SD点位 = 枚举.SD枚举.推动3反;
                        运动控制数据.SD写入 = true;
                        break;
                    }
                case "推动四反":
                    {
                        运动控制数据.修改SD点位 = 枚举.SD枚举.推动4反;
                        运动控制数据.SD写入 = true;
                        break;
                    }

            }
            窗口.主页主显示.显示("长按:" + button.Name);

        }

        private void bt_MouseUp(object sender, RoutedEventArgs e)
        {
            Button button = (Button)sender;
            运动控制数据.SD归零 = true;
            窗口.主页主显示.显示("松开:" + button.Name);



        }

        private void UserControl_Loaded(object sender, RoutedEventArgs e)
        {
            配方选择.ItemsSource = 获取料号();
            string 主path = 运动控制数据.主路径 + "\\主参数.ini";
            try
            {

                配方选择.SelectedIndex = Convert.ToInt16(IniFile.Read_Value(主path, "主控", "当前选择配方", "0"));

            }
            catch { }
        }
    }
}
